using System;
using System.Collections.Generic;
using System.IO;
using Newtonsoft.Json;
using UnityEngine;

namespace Utils
{
    public static class FileHandler
    {
        // 保存文件的默认文件夹路径
        private const string FolderPath = "save";

        /// <summary>
        /// 初始化文件夹
        /// </summary>
        static FileHandler()
        {
            if (!Directory.Exists(FolderPath))
            {
                Directory.CreateDirectory(FolderPath);
            }
        }

        /// <summary>
        /// 保存单个类为 JSON 文件
        /// </summary>
        /// <param name="obj">要保存的类对象</param>
        /// <param name="fileName">可选的文件名（不包括扩展名）</param>
        public static bool SaveFile<T>(T obj, string fileName = null)
        {
            try
            {
                // 如果未提供文件名，则使用类名作为文件名
                if (string.IsNullOrEmpty(fileName))
                {
                    fileName = typeof(T).Name;
                }

                // 构建完整的文件路径
                var filePath = Path.Combine(FolderPath, fileName + ".json");

                // 将对象序列化为 JSON 字符串
                var jsonContent = JsonConvert.SerializeObject(obj, Formatting.Indented);

                // 写入文件
                File.WriteAllText(filePath, jsonContent);

                Debug.Log($"Saved file: {filePath}");
          
                return true;
            }
            catch (Exception ex)
            {
                Debug.LogError($"Failed to save file: {ex.Message}");
                return false;
            }
        }

        /// <summary>
        /// 从 JSON 文件读取单个类
        /// </summary>
        /// <param name="fileName">文件名（不包括扩展名）</param>
        public static T LoadFile<T>(string fileName)
        {
            try
            {
                // 构建完整的文件路径
                var filePath = Path.Combine(FolderPath, fileName + ".json");

                // 检查文件是否存在
                if (!File.Exists(filePath))
                {
                    Debug.LogError($"File not found: {filePath}");
                    return default;
                }

                // 读取文件内容
                var jsonContent = File.ReadAllText(filePath);

                // 反序列化为指定类型的对象
                var obj = JsonConvert.DeserializeObject<T>(jsonContent);

                Debug.Log($"Loaded file: {filePath}");
                return obj;
            }
            catch (Exception ex)
            {
                Debug.LogError($"Failed to load file: {ex.Message}");
                return default;
            }
        }

        /// <summary>
        /// 打包多个类并保存为一个存档文件
        /// </summary>
        /// <param name="archiveName">存档文件名（不包括扩展名）</param>
        /// <param name="objects">要保存的类对象字典</param>
        public static bool SaveArchive(string archiveName, Dictionary<string, object> objects)
        {
            try
            {
                // 构建完整的文件路径
                var filePath = Path.Combine(FolderPath, archiveName + ".archive.json");

                // 将字典中的对象序列化为 JSON
                var jsonContent = JsonConvert.SerializeObject(objects, Formatting.Indented);

                // 写入文件
                File.WriteAllText(filePath, jsonContent);

                Debug.Log($"Saved archive: {filePath}");
                return true;
            }
            catch (Exception ex)
            {
                Debug.LogError($"Failed to save archive: {ex.Message}");
                return false;
            }
        }

        /// <summary>
        /// 从存档文件中读取多个类
        /// </summary>
        /// <param name="archiveName">存档文件名（不包括扩展名）</param>
        public static Dictionary<string, object> LoadArchive(string archiveName)
        {
            try
            {
                // 构建完整的文件路径
                var filePath = Path.Combine(FolderPath, archiveName + ".archive.json");

                // 检查文件是否存在
                if (!File.Exists(filePath))
                {
                    Debug.LogError($"Archive not found: {filePath}");
                    return null;
                }

                // 读取文件内容
                var jsonContent = File.ReadAllText(filePath);

                // 反序列化为字典
                Dictionary<string, object> objects = JsonConvert.DeserializeObject<Dictionary<string, object>>(jsonContent);

                Debug.Log($"Loaded archive: {filePath}");
                return objects;
            }
            catch (Exception ex)
            {
                Debug.LogError($"Failed to load archive: {ex.Message}");
                return null;
            }
        }
        
        /// <summary>
        /// 获取指定路径下的所有xml文件
        /// </summary>
        /// <param name="paths">文件夹路径</param>
        /// <returns></returns>
        public static List<string> LoadXmlFilesFromPaths(string[] paths)
        {
            var xmlFilePaths = new List<string>();

            foreach (var path in paths)
            {
                // 获取程序所在的目录路径
                var appDirectory = AppDomain.CurrentDomain.BaseDirectory;

                // 构建目标目录的完整路径
                var dataDirectory = Path.Combine(appDirectory, path);

                try
                {
                    // 检查目录是否存在
                    if (Directory.Exists(dataDirectory))
                    {
                        // 获取目录下的所有子文件夹
                        var subDirectories = Directory.GetDirectories(dataDirectory);

                        // 遍历并收集每个子文件夹中的 XML 文件
                        foreach (var dir in subDirectories)
                        {
                            var xmlFiles = Directory.GetFiles(dir, "*.xml", SearchOption.AllDirectories);
                            xmlFilePaths.AddRange(xmlFiles);
                        }
                    }
                }
                catch (Exception ex)
                {
                    Debug.LogError($"加载文件时发生错误: {ex.Message}");
                }
            }

            return xmlFilePaths;
        }
    }

}